﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Mail;
using System.Text;
using System.Web.Mvc;
using Comissoes.Models;
using System.IO;
using System.Xml.Serialization;
using System.Xml;
using System.Xml.Linq;

namespace Comissoes.Utilities
{
    public abstract class Mail
    {
        // Envia os e-mails operacionais do sistema aos usuários
        public static string SendMail(Controller controller, xcontEntities db, string titulo, int id_pessoa, char acao, int? cod_loja)
        {
            try
            {
                PESSOAS pessoa = db.PESSOAS.FirstOrDefault(t => t.ID_PESSOA.Equals(id_pessoa));
                OPERADORES oper = db.OPERADORES.FirstOrDefault(t => t.PESSOAS.ID_PESSOA == pessoa.ID_PESSOA);
                var email = db.EMAILS.Where(t => t.PESSOAS.Equals(pessoa.ID_PESSOA)).ToList();

                foreach (var em in email)
                {
                    MailMessage mail = new MailMessage();
                    mail.To.Add(em.ENDERECO_EMAIL);
                    mail.From = new MailAddress("Comissoes@Comissoes.com.br");
                    mail.Subject = string.Format("[Comissoes] - {0}", titulo);

                    StringBuilder Body = new StringBuilder();
                    Body.AppendLine("<div style=\"display: block; border: solid 1px #92C6EB; width: 542px; height: 70px; \">");
                    Body.AppendLine("<img src=\"cid:header\" />");
                    Body.AppendLine("</div>");
                    Body.AppendLine("<div style=\"border: solid 1px #92C6EB; background: url('cid:email_r14') repeat-x; width: 542px; \">");
                    Body.AppendLine(string.Format("<h1 style=\"color: #003991; font-size: 1.4em; font-family: 'Agency FB', Arial; width: 542px; text-align: center;\">{0}</h1>", titulo));
                    Body.AppendLine("<p style=\"width: 520px; text-align: justify; font: normal normal normal .9em Arial; margin: 10px;\">");
                    if (acao.Equals('A')) // Envio de cadastro de nova loja
                    {
                        var loja = db.LOJAS.FirstOrDefault(t => t.COD_LOJA.Equals(cod_loja));

                        Body.AppendLine(string.Format("Olá {0}<br /><br />", pessoa.FANTASIA_PESSOA));
                        Body.AppendLine(string.Format("Informamos que uma nova loja foi cadastrada no sistema em {0}, sob código nº {1}.<br />", DateTime.Now.ToShortDateString(), loja.COD_LOJA));
                        Body.AppendLine("Para visualizar os dados da loja, acesse o sistema em Cadastro/Lojas.");
                        Body.AppendLine("</p>");
                    }
                    Body.AppendLine("</div>");
                    Body.AppendLine("<div style=\"width: 520px; margin: 10px;\">");
                    Body.AppendLine("<p style=\"width: 510px; text-align: center; font: normal normal normal .7em Arial; \">");
                    Body.AppendLine("Atendimento  - Segunda a sábado: 08:00 às 22:00h Domingos e feriados: 10:00 às 22:00h<br />");
                    Body.AppendLine("Suporte - Telefone: (11)3384-2977 / 2295-1677 Skype: suporte1.rcky Chat: <a href=\"www.rcky.com.br\">www.rcky.com.br</a><br />");
                    Body.AppendLine("RCKY Informática - Rua Betari, 229 Penha");
                    Body.AppendLine("</p>");
                    Body.AppendLine("</div>");

                    AlternateView htmlView = AlternateView.CreateAlternateViewFromString(Body.ToString(), null, "text/html");

                    LinkedResource email_r14 = new LinkedResource(controller.Server.MapPath("/Content/Images/Emails") + @"\email_r14.png", "image/png");
                    LinkedResource header = new LinkedResource(controller.Server.MapPath("/Content/Images/Emails") + @"\header.png", "image/png");

                    email_r14.ContentId = "email_r14";
                    header.ContentId = "header";

                    email_r14.TransferEncoding = System.Net.Mime.TransferEncoding.Base64;
                    header.TransferEncoding = System.Net.Mime.TransferEncoding.Base64;

                    htmlView.LinkedResources.Add(email_r14);
                    htmlView.LinkedResources.Add(header);

                    mail.AlternateViews.Add(htmlView);
                    SmtpClient smtp = new SmtpClient();
                    smtp.Host = "localhost";
                    smtp.Port = 25;
                    smtp.EnableSsl = false;
                    smtp.Send(mail);
                }

                return string.Empty;
            }

            catch (Exception ex)
            {
                return ex.Message;
            }
        }
    }

    public static class XmlExtensions
    {
        public static XmlDocument ToXmlDocument(this XDocument xDocument)
        {
            var xmlDocument = new XmlDocument();
            using (var xmlReader = xDocument.CreateReader())
            {
                xmlDocument.Load(xmlReader);
            }
            return xmlDocument;
        }

        public static XmlDocument ToXmlDocument(XElement xElement)
        {
            var xmlDocument = new XmlDocument();
            using (var xmlReader = xElement.CreateReader())
            {
                xmlDocument.Load(xmlReader);
            }
            return xmlDocument;
        }

        public static XDocument ToXDocument(this XmlDocument xmlDocument)
        {
            using (var nodeReader = new XmlNodeReader(xmlDocument))
            {
                nodeReader.MoveToContent();
                return XDocument.Load(nodeReader);
            }
        }
    }

    public abstract class Serializadores
    {
        /// <summary>
        /// Converter um objeto para uma string em XML
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="Objeto">Objeto que sera serializado</param>
        /// <returns>String XML</returns>
        public static String SerializeXMLObject<T>(T Obj)
        {
            try
            {
                String XmlizedString = null;
                MemoryStream memoryStream = new MemoryStream();
                XmlSerializer xs = new XmlSerializer(typeof(T));
                XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, new UTF8Encoding(false));

                xs.Serialize(xmlTextWriter, Obj);
                memoryStream = (MemoryStream)xmlTextWriter.BaseStream;
                XmlizedString = UTF8ByteArrayToString(memoryStream.ToArray());

                return XmlizedString;
            }

            catch (Exception ex)
            {

                return ex.Message;
            }
        }

        /// <summary>
        /// Converter um array de bytes em string.
        /// </summary>
        /// <param name="characters">Array que será convertido</param>
        /// <returns>String</returns>
        public static String UTF8ByteArrayToString(Byte[] buffer)
        {
            UTF8Encoding encoding = new UTF8Encoding(false);

            String constructedString = encoding.GetString(buffer);

            return (constructedString);
        }

        /// <summary>
        /// Converter uma string XML serializada para um array de bytes
        /// </summary>
        /// <param name="StringXml">String XML</param>
        /// <returns>Byte[]</returns>
        public static Byte[] StringToUTF8ByteArray(String StringXml)
        {
            UTF8Encoding encoding = new UTF8Encoding();

            Byte[] byteArray = encoding.GetBytes(StringXml);

            return byteArray;
        } 
    }

    /// <summary>
    /// Classe abstrata para validações
    /// </summary>
    public abstract class Convertions
    {
        /// <summary>
        /// Converte o valor passado para documento
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static String tString<T>(T value)
        {
            if (value == null)
            {
                return null;
            }
            else
            {
                return value.ToString();
            }
        }

        /// <summary>
        /// Converte o valor passado para documento
        /// </summary>
        /// <param name="value"></param>
        /// <param name="precision"></param>
        /// <returns></returns>
        public static String tString<T>(T value, Int32 precision)
        {
            if (value == null)
            {
                return String.Format("0.{0}", String.Empty.PadRight(precision, '0'));
            }
            else
            {
                return value.ToString().Replace(',', '.');
            }
        }

        /// <summary>
        /// Converte o valor passado para documento
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static String Documento(String value)
        {
            return value.Replace(".", "").Replace("/", "").Replace("-", "");
        }

        /// <summary>
        /// Converte o valor passado para decimal
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static Decimal? Decimal(String value)
        {
            if (String.IsNullOrEmpty(value)) {
                return null;
            }

            value = value.Replace("R$ ", "");

            if (Validations.Decimal(value))
            {
                return decimal.Parse(value);
            }

            return null;
        }

        /// <summary>
        /// Converte o valor passado para inteiro
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static Int32? Inteiro(String value)
        {
            if (String.IsNullOrEmpty(value) || !Validations.Inteiro(value))
                return null;
            else
                return Int32.Parse(value);
        }

        /// <summary>
        /// Converte o valor passado para data
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static DateTime? Data(String value)
        {
            if (String.IsNullOrEmpty(value) || !Validations.Data(value))
                return null;
            else
                return DateTime.Parse(value);
        }
    }

    /// <summary>
    /// Classe abstrata para validações
    /// </summary>
    public abstract class Validations
    {
        /// <summary>
        /// Validar Cpf
        /// </summary>
        /// <param name="Cpf"></param>
        /// <returns></returns>
        public static bool Cpf(string Cpf)
        {
            string cpf = Cpf.Trim().Replace(".", string.Empty).Replace("/", string.Empty).Replace("-", string.Empty);

            int[] multiplicador1 = new int[9] { 10, 9, 8, 7, 6, 5, 4, 3, 2 };
            int[] multiplicador2 = new int[10] { 11, 10, 9, 8, 7, 6, 5, 4, 3, 2 };
            string tempCpf, digito;

            int soma, resto;
            if (cpf.Length != 11) return false;
            tempCpf = cpf.Substring(0, 9);
            soma = 0;
            for (int i = 0; i < 9; i++) soma += int.Parse(tempCpf[i].ToString()) * multiplicador1[i];
            resto = soma % 11;
            if (resto < 2) resto = 0;
            else resto = 11 - resto;
            digito = resto.ToString();
            tempCpf = tempCpf + digito;
            soma = 0;
            for (int i = 0; i < 10; i++) soma += int.Parse(tempCpf[i].ToString()) * multiplicador2[i];
            resto = soma % 11;
            if (resto < 2) resto = 0;
            else resto = 11 - resto;
            digito = digito + resto.ToString();

            return cpf.EndsWith(digito);
        }

        /// <summary>
        /// Validar CNPJ
        /// </summary>
        /// <param name="Cnpj"></param>
        /// <returns></returns>
        public static bool Cnpj(string Cnpj)
        {
            string CNPJ = Cnpj.Replace(".", string.Empty).Replace("/", string.Empty).Replace("-", string.Empty);
            int[] soma = new int[2] { 0, 0 }, resultado = new int[2] { 0, 0 }, digitos = new int[14];
            string fmt = "6543298765432";
            bool CNPJOk = false;

            try
            {
                for (int i = 0; i < 14; i++)
                {
                    digitos[i] = int.Parse(CNPJ.Substring(i, 1));
                    if (i <= 11)
                    {
                        soma[0] += (digitos[i] * int.Parse(fmt.Substring(i + 1, 1)));
                    }
                    if (i <= 12)
                    {
                        soma[1] += (digitos[i] * int.Parse(fmt.Substring(i, 1)));
                    }
                }

                for (int i = 0; i < 2; i++)
                {
                    resultado[i] = (soma[i] % 11);
                    if ((resultado[i] == 0) || (resultado[i] == 1))
                    {
                        if (digitos[12 + i] == 0)
                            CNPJOk = true;
                    }
                    else
                    {
                        if (digitos[12 + i] == (11 - resultado[i]))
                            CNPJOk = true;
                    }
                }

                return CNPJOk;
            }

            catch
            {
                return false;
            }
        }
        
        /// <summary>
        /// Validar CNPJ
        /// </summary>
        /// <param name="Cnpj"></param>
        /// <returns></returns>
        public static bool IE(String UF, String IE)
        {
            bool retorno = false;

            String Base = String.Empty, Base2 = String.Empty, Origem = String.Empty, Digito, Digito2;
            Int32 intPos, intValor, intSoma = 0, intResto, intNumero, intPeso, intDig;

            for (intPos = 1; intPos <= IE.Length; intPos++)
            {
                if ((("0123456789P".IndexOf(IE.Substring((intPos - 1), 1), 0, System.StringComparison.OrdinalIgnoreCase) + 1) > 0))
                {
                    Origem = (Origem + IE.Substring((intPos - 1), 1));
                }
            }

            switch (UF.ToUpper())
            {
                case "AC": Base = (Origem.Trim() + "000000000").Substring(0, 9); if (((Base.Substring(0, 2) == "01") && (Base.Substring(2, 2) != "00"))) { intSoma = 0; for (intPos = 1; (intPos <= 8); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (10 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 11); Digito = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); Base2 = (Base.Substring(0, 8) + Digito); if ((Base2 == Origem)) { retorno = true; } } break;
                case "AL": Base = (Origem.Trim() + "000000000").Substring(0, 9); if ((Base.Substring(0, 2) == "24")) { intSoma = 0; for (intPos = 1; (intPos <= 8); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (10 - intPos)); intSoma = (intSoma + intValor); } intSoma = (intSoma * 10); intResto = (intSoma % 11); Digito = ((intResto == 10) ? "0" : Convert.ToString(intResto)).Substring((((intResto == 10) ? "0" : Convert.ToString(intResto)).Length - 1)); Base2 = (Base.Substring(0, 8) + Digito); if ((Base2 == Origem)) { retorno = true; } } break;
                case "AM": Base = (Origem.Trim() + "000000000").Substring(0, 9); intSoma = 0; for (intPos = 1; (intPos <= 8); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (10 - intPos)); intSoma = (intSoma + intValor); } if ((intSoma < 11)) { Digito = Convert.ToString((11 - intSoma)).Substring((Convert.ToString((11 - intSoma)).Length - 1)); } else { intResto = (intSoma % 11); Digito = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); } Base2 = (Base.Substring(0, 8) + Digito); if ((Base2 == Origem)) { retorno = true; } break;
                case "AP": Base = (Origem.Trim() + "000000000").Substring(0, 9); intPeso = 0; intDig = 0; if ((Base.Substring(0, 2) == "03")) { intNumero = int.Parse(Base.Substring(0, 8)); if (((intNumero >= 3000001) && (intNumero <= 3017000))) { intPeso = 5; intDig = 0; } else if (((intNumero >= 3017001) && (intNumero <= 3019022))) { intPeso = 9; intDig = 1; } else if ((intNumero >= 3019023)) { intPeso = 0; intDig = 0; } intSoma = intPeso; for (intPos = 1; (intPos <= 8); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (10 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 11); intValor = (11 - intResto); if ((intValor == 10)) { intValor = 0; } else if ((intValor == 11)) { intValor = intDig; } Digito = Convert.ToString(intValor).Substring((Convert.ToString(intValor).Length - 1)); Base2 = (Base.Substring(0, 8) + Digito); if ((Base2 == Origem)) { retorno = true; } } break;
                case "BA": Base = (Origem.Trim() + "00000000").Substring(0, 8); if ((("0123458".IndexOf(Base.Substring(0, 1), 0, System.StringComparison.OrdinalIgnoreCase) + 1) > 0)) { intSoma = 0; for (intPos = 1; (intPos <= 6); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (8 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 10); Digito2 = ((intResto == 0) ? "0" : Convert.ToString((10 - intResto))).Substring((((intResto == 0) ? "0" : Convert.ToString((10 - intResto))).Length - 1)); Base2 = (Base.Substring(0, 6) + Digito2); intSoma = 0; for (intPos = 1; (intPos <= 7); intPos++) { intValor = int.Parse(Base2.Substring((intPos - 1), 1)); intValor = (intValor * (9 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 10); Digito = ((intResto == 0) ? "0" : Convert.ToString((10 - intResto))).Substring((((intResto == 0) ? "0" : Convert.ToString((10 - intResto))).Length - 1)); } else { intSoma = 0; for (intPos = 1; (intPos <= 6); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (8 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 11); Digito2 = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); Base2 = (Base.Substring(0, 6) + Digito2); intSoma = 0; for (intPos = 1; (intPos <= 7); intPos++) { intValor = int.Parse(Base2.Substring((intPos - 1), 1)); intValor = (intValor * (9 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 11); Digito = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); } Base2 = (Base.Substring(0, 6) + (Digito + Digito2)); if ((Base2 == Origem)) { retorno = true; } break;
                case "CE": Base = (Origem.Trim() + "000000000").Substring(0, 9); intSoma = 0; for (intPos = 1; (intPos <= 8); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (10 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 11); intValor = (11 - intResto); if ((intValor > 9)) { intValor = 0; } Digito = Convert.ToString(intValor).Substring((Convert.ToString(intValor).Length - 1)); Base2 = (Base.Substring(0, 8) + Digito); if ((Base2 == Origem)) { retorno = true; } break;
                case "DF": Base = (Origem.Trim() + "0000000000000").Substring(0, 13); if ((Base.Substring(0, 3) == "073")) { intSoma = 0; intPeso = 2; for (intPos = 11; (intPos <= 1); intPos = (intPos + -1)) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * intPeso); intSoma = (intSoma + intValor); intPeso = (intPeso + 1); if ((intPeso > 9)) { intPeso = 2; } } intResto = (intSoma % 11); Digito = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); Base2 = (Base.Substring(0, 11) + Digito); intSoma = 0; intPeso = 2; for (intPos = 12; (intPos <= 1); intPos = (intPos + -1)) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * intPeso); intSoma = (intSoma + intValor); intPeso = (intPeso + 1); if ((intPeso > 9)) { intPeso = 2; } } intResto = (intSoma % 11); Digito2 = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); Base2 = (Base.Substring(0, 12) + Digito2); if ((Base2 == Origem)) { retorno = true; } } break;
                case "ES": Base = (Origem.Trim() + "000000000").Substring(0, 9); intSoma = 0; for (intPos = 1; (intPos <= 8); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (10 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 11); Digito = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); Base2 = (Base.Substring(0, 8) + Digito); if ((Base2 == Origem)) { retorno = true; } break;
                case "GO": Base = (Origem.Trim() + "000000000").Substring(0, 9); if ((("10,11,15".IndexOf(Base.Substring(0, 2), 0, System.StringComparison.OrdinalIgnoreCase) + 1) > 0)) { intSoma = 0; for (intPos = 1; (intPos <= 8); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (10 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 11); if ((intResto == 0)) { Digito = "0"; } else if ((intResto == 1)) { intNumero = int.Parse(Base.Substring(0, 8)); Digito = (((intNumero >= 10103105) && (intNumero <= 10119997)) ? "1" : "0").Substring(((((intNumero >= 10103105) && (intNumero <= 10119997)) ? "1" : "0").Length - 1)); } else { Digito = Convert.ToString((11 - intResto)).Substring((Convert.ToString((11 - intResto)).Length - 1)); } Base2 = (Base.Substring(0, 8) + Digito); if ((Base2 == Origem)) { retorno = true; } } break;
                case "MA": Base = (Origem.Trim() + "000000000").Substring(0, 9); if ((Base.Substring(0, 2) == "12")) { intSoma = 0; for (intPos = 1; (intPos <= 8); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (10 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 11); Digito = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); Base2 = (Base.Substring(0, 8) + Digito); if ((Base2 == Origem)) { retorno = true; } } break;
                case "MT": Base = (Origem.Trim() + "0000000000").Substring(0, 10); intSoma = 0; intPeso = 2; for (intPos = 10; (intPos <= 1); intPos = (intPos + -1)) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * intPeso); intSoma = (intSoma + intValor); intPeso = (intPeso + 1); if ((intPeso > 9)) { intPeso = 2; } } intResto = (intSoma % 11); Digito = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); Base2 = (Base.Substring(0, 10) + Digito); if ((Base2 == Origem)) { retorno = true; } break;
                case "MS": Base = (Origem.Trim() + "000000000").Substring(0, 9); if ((Base.Substring(0, 2) == "28")) { intSoma = 0; for (intPos = 1; (intPos <= 8); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (10 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 11); Digito = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); Base2 = (Base.Substring(0, 8) + Digito); if ((Base2 == Origem)) { retorno = true; } } break;
                case "MG": Base = (Origem.Trim() + "0000000000000").Substring(0, 13); Base2 = (Base.Substring(0, 3) + ("0" + Base.Substring(3, 8))); intNumero = 2; for (intPos = 1; (intPos <= 12); intPos++) { intValor = int.Parse(Base2.Substring((intPos - 1), 1)); intNumero = ((intNumero == 2) ? 1 : 2); intValor = (intValor * intNumero); if ((intValor > 9)) { Digito = string.Format("00", intValor); intValor = (int.Parse(Digito.Substring(0, 1)) + int.Parse(Digito.Substring((Digito.Length - 1)))); } intSoma = (intSoma + intValor); } intValor = intSoma; while ((string.Format("000", intValor).Substring((string.Format("000", intValor).Length - 1)) != "0")) { intValor = (intValor + 1); Digito = string.Format("00", (intValor - intSoma)).Substring((string.Format("00", (intValor - intSoma)).Length - 1)); Base2 = (Base.Substring(0, 11) + Digito); intSoma = 0; intPeso = 2; for (intPos = 12; (intPos <= 1); intPos = (intPos + -1)) { intValor = int.Parse(Base2.Substring((intPos - 1), 1)); intValor = (intValor * intPeso); intSoma = (intSoma + intValor); intPeso = (intPeso + 1); if ((intPeso > 11)) { intPeso = 2; } } intResto = (intSoma % 11); Digito2 = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); Base2 = (Base2 + Digito2); if ((Base2 == Origem)) { retorno = true; } } break;
                case "PA": Base = (Origem.Trim() + "000000000").Substring(0, 9); if ((Base.Substring(0, 2) == "15")) { intSoma = 0; for (intPos = 1; (intPos <= 8); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (10 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 11); Digito = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); Base2 = (Base.Substring(0, 8) + Digito); if ((Base2 == Origem)) { retorno = true; } } break;
                case "PB": Base = (Origem.Trim() + "000000000").Substring(0, 9); intSoma = 0; for (intPos = 1; (intPos <= 8); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (10 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 11); intValor = (11 - intResto); if ((intValor > 9)) { intValor = 0; } Digito = Convert.ToString(intValor).Substring((Convert.ToString(intValor).Length - 1)); Base2 = (Base.Substring(0, 8) + Digito); if ((Base2 == Origem)) { retorno = true; } break;
                case "PE": Base = (Origem.Trim() + "00000000000000").Substring(0, 14); intSoma = 0; intPeso = 2; for (intPos = 13; (intPos <= 1); intPos = (intPos + -1)) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * intPeso); intSoma = (intSoma + intValor); intPeso = (intPeso + 1); if ((intPeso > 9)) { intPeso = 2; } } intResto = (intSoma % 11); intValor = (11 - intResto); if ((intValor > 9)) { intValor = (intValor - 10); } Digito = Convert.ToString(intValor).Substring((Convert.ToString(intValor).Length - 1)); Base2 = (Base.Substring(0, 13) + Digito); if ((Base2 == Origem)) { retorno = true; } break;
                case "PI": Base = (Origem.Trim() + "000000000").Substring(0, 9); intSoma = 0; for (intPos = 1; (intPos <= 8); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (10 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 11); Digito = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); Base2 = (Base.Substring(0, 8) + Digito); if ((Base2 == Origem)) { retorno = true; } break;
                case "PR": Base = (Origem.Trim() + "0000000000").Substring(0, 10); intSoma = 0; intPeso = 2; for (intPos = 8; (intPos <= 1); intPos = (intPos + -1)) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * intPeso); intSoma = (intSoma + intValor); intPeso = (intPeso + 1); if ((intPeso > 7)) { intPeso = 2; } } intResto = (intSoma % 11); Digito = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); Base2 = (Base.Substring(0, 8) + Digito); intSoma = 0; intPeso = 2; for (intPos = 9; (intPos <= 1); intPos = (intPos + -1)) { intValor = int.Parse(Base2.Substring((intPos - 1), 1)); intValor = (intValor * intPeso); intSoma = (intSoma + intValor); intPeso = (intPeso + 1); if ((intPeso > 7)) { intPeso = 2; } } intResto = (intSoma % 11); Digito2 = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); Base2 = (Base2 + Digito2); if ((Base2 == Origem)) { retorno = true; } break;
                case "RJ": Base = (Origem.Trim() + "00000000").Substring(0, 8); intSoma = 0; intPeso = 2; for (intPos = 7; (intPos <= 1); intPos = (intPos + -1)) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * intPeso); intSoma = (intSoma + intValor); intPeso = (intPeso + 1); if ((intPeso > 7)) { intPeso = 2; } } intResto = (intSoma % 11); Digito = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); Base2 = (Base.Substring(0, 7) + Digito); if ((Base2 == Origem)) { retorno = true; } break;
                case "RN": Base = (Origem.Trim() + "000000000").Substring(0, 9); if ((Base.Substring(0, 2) == "20")) { intSoma = 0; for (intPos = 1; (intPos <= 8); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (10 - intPos)); intSoma = (intSoma + intValor); } intSoma = (intSoma * 10); intResto = (intSoma % 11); Digito = ((intResto > 9) ? "0" : Convert.ToString(intResto)).Substring((((intResto > 9) ? "0" : Convert.ToString(intResto)).Length - 1)); Base2 = (Base.Substring(0, 8) + Digito); if ((Base2 == Origem)) { retorno = true; } } break;
                case "RO": Base = (Origem.Trim() + "000000000").Substring(0, 9); Base2 = Base.Substring(3, 5); intSoma = 0; for (intPos = 1; (intPos <= 5); intPos++) { intValor = int.Parse(Base2.Substring((intPos - 1), 1)); intValor = (intValor * (7 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 11); intValor = (11 - intResto); if ((intValor > 9)) { intValor = (intValor - 10); } Digito = Convert.ToString(intValor).Substring((Convert.ToString(intValor).Length - 1)); Base2 = (Base.Substring(0, 8) + Digito); if ((Base2 == Origem)) { retorno = true; } break;
                case "RR": Base = (Origem.Trim() + "000000000").Substring(0, 9); if ((Base.Substring(0, 2) == "24")) { intSoma = 0; for (intPos = 1; (intPos <= 8); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (10 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 9); Digito = Convert.ToString(intResto).Substring((Convert.ToString(intResto).Length - 1)); Base2 = (Base.Substring(0, 8) + Digito); if ((Base2 == Origem)) { retorno = true; } } break;
                case "RS": Base = (Origem.Trim() + "0000000000").Substring(0, 10); intNumero = int.Parse(Base.Substring(0, 3)); if (((intNumero > 0) && (intNumero < 468))) { intSoma = 0; intPeso = 2; for (intPos = 9; (intPos <= 1); intPos = (intPos + -1)) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * intPeso); intSoma = (intSoma + intValor); intPeso = (intPeso + 1); if ((intPeso > 9)) { intPeso = 2; } } intResto = (intSoma % 11); intValor = (11 - intResto); if ((intValor > 9)) { intValor = 0; } Digito = Convert.ToString(intValor).Substring((Convert.ToString(intValor).Length - 1)); Base2 = (Base.Substring(0, 9) + Digito); if ((Base2 == Origem)) { retorno = true; } } break;
                case "SC": Base = (Origem.Trim() + "000000000").Substring(0, 9); intSoma = 0; for (intPos = 1; (intPos <= 8); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (10 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 11); Digito = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); Base2 = (Base.Substring(0, 8) + Digito); if ((Base2 == Origem)) { retorno = true; } break;
                case "SE": Base = (Origem.Trim() + "000000000").Substring(0, 9); intSoma = 0; for (intPos = 1; (intPos <= 8); intPos++) { intValor = int.Parse(Base.Substring((intPos - 1), 1)); intValor = (intValor * (10 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 11); intValor = (11 - intResto); if ((intValor > 9)) { intValor = 0; } Digito = Convert.ToString(intValor).Substring((Convert.ToString(intValor).Length - 1)); Base2 = (Base.Substring(0, 8) + Digito); if ((Base2 == Origem)) { retorno = true; } break;
                case "SP": Int32[] pesos = new Int32[] { 1, 3, 4, 5, 6, 7, 8, 10 }; Char[] ie = IE.ToCharArray(); Int32 total = 0; Int32 ponderacao; if (ie.First() == 'P') { for (Int32 i = 1; i < pesos.Length; i++) { total += Int32.Parse(ie[i + 1].ToString()) * pesos[i]; }; ponderacao = total % 11 == 10 ? 0 : total % 11; if (ponderacao == Int32.Parse(ie[9].ToString())) { retorno = true; } } else { for (Int32 i = 0; i < pesos.Length; i++) { total += Int32.Parse(ie[i].ToString()) * pesos[i]; }; ponderacao = total % 11 == 10 ? 0 : total % 11; if (ponderacao == Int32.Parse(ie[8].ToString())) { pesos = new Int32[] { 3, 2, 10, 9, 8, 7, 6, 5, 4, 3, 2 }; total = 0; for (Int32 i = 0; i < pesos.Length; i++) { total += Int32.Parse(ie[i].ToString()) * pesos[i]; }; if (total % 11 == Int32.Parse(ie[11].ToString())) { retorno = true; } } } break;
                case "TO": Base = (Origem.Trim() + "00000000000").Substring(0, 11); if ((("01,02,03,99".IndexOf(Base.Substring(2, 2), 0, System.StringComparison.OrdinalIgnoreCase) + 1) > 0)) { Base2 = (Base.Substring(0, 2) + Base.Substring(4, 6)); intSoma = 0; for (intPos = 1; (intPos <= 8); intPos++) { intValor = int.Parse(Base2.Substring((intPos - 1), 1)); intValor = (intValor * (10 - intPos)); intSoma = (intSoma + intValor); } intResto = (intSoma % 11); Digito = ((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Substring((((intResto < 2) ? "0" : Convert.ToString((11 - intResto))).Length - 1)); Base2 = (Base.Substring(0, 10) + Digito); if ((Base2 == Origem)) { retorno = true; } } break;
            }

            return retorno;
        }

        /// <summary>
        /// Valida Data
        /// </summary>
        /// <param name="valor">data</param>
        /// <returns></returns>
        public static bool Data(string valor)
        {
            try
            {
                DateTime date = DateTime.Parse(valor);

                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// Valida Decimal
        /// </summary>
        /// <param name="valor">campo decimal</param>
        /// <returns></returns>
        public static bool Decimal(string valor)
        {
            try
            {
                decimal data = decimal.Parse(valor);

                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// Valida Inteiros
        /// </summary>
        /// <param name="valor">campo decimal</param>
        /// <returns></returns>
        public static bool Inteiro(string valor)
        {
            try
            {
                int data = int.Parse(valor);

                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// Valida Hora
        /// </summary>
        /// <param name="valor">hora</param>
        /// <returns></returns>
        public static bool Hora(string valor)
        {
            try
            {
                DateTime date = DateTime.Parse("01/01/2009 " + valor);

                return true;
            }
            catch
            {
                return false;
            }
        }
    }

    /// <summary>
    /// Classe abstrata para criação dinâmica das listas mais utilizadas
    /// </summary>
    public abstract class Lists
    {
    }

    /// <summary>
    /// Classe abstrata para aplicar máscaras de formatos
    /// </summary>
    public abstract class Formats
    {


        /// <summary>
        /// Traduz os dias da semana para o formato pt-BR
        /// </summary>
        /// <param name="dia">O dia da semana que será formatado</param>
        /// <param name="extenso">complemento nos dias úteis da semana, será comlementado de '-Feira'</param>
        /// <returns>Dia da semana formatado</returns>
        public static string DiaSemana(DayOfWeek dia, bool extenso)
        {
            switch (dia)
            {
                case DayOfWeek.Sunday: return "Domingo";
                case DayOfWeek.Monday: return extenso ? "Segunda-Feira" : "Segunda";
                case DayOfWeek.Tuesday: return extenso ? "Terça-Feira" : "Terça";
                case DayOfWeek.Wednesday: return extenso ? "Quarta-Feira" : "Quarta";
                case DayOfWeek.Thursday: return extenso ? "Quinta-Feira" : "Quinta";
                case DayOfWeek.Friday: return extenso ? "Sexta-Feira" : "Sexta";
                default: return "Sábado";
            }
        }

        /// <summary>
        /// Aplica máscara de CPF/CNPJ
        /// </summary>
        /// <param name="documento"></param>
        /// <returns></returns>
        public static string CpfCnpj(string documento)
        {
            string buffer;
            switch (documento.Length)
            {
                case 11:
                    // CPF
                    buffer = string.Format("{0}.{1}.{2}-{3}",
                        documento.Substring(0, 3),
                        documento.Substring(3, 3),
                        documento.Substring(6, 3),
                        documento.Substring(9, 2));
                    break;
                case 12:
                    // IE
                    buffer = string.Format("{0}.{1}.{2}.{3}",
                       documento.Substring(0, 3),
                       documento.Substring(3, 3),
                       documento.Substring(6, 3),
                       documento.Substring(9, 3));
                    break;
                case 14:
                    // CNPJ
                    buffer = string.Format("{0}.{1}.{2}/{3}-{4}",
                       documento.Substring(0, 2),
                       documento.Substring(2, 3),
                       documento.Substring(5, 3),
                       documento.Substring(8, 4),
                       documento.Substring(12, 2));
                    break;
                default:
                    buffer = documento;
                    break;
            }

            return buffer;
        }

        /// <summary>
        /// Aplica máscara de CEP
        /// </summary>
        /// <param name="cep"></param>
        /// <returns></returns>
        public static string Cep(string cep)
        {
            return cep.Substring(0, 5) + "-" + cep.Substring(5, 3);
        }

        /// <summary>
        /// Aplica máscara de dia e mês
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static string DiaMes(string data)
        {
            if (data != null)
                return string.Format("{0}/{1}", data.Substring(0, 2), data.Substring(2, 2));
            else
                return string.Empty;
        }

        /// <summary>
        /// Retorna data inicial das pesquisas
        /// </summary>
        /// <param name="request">Request da data inicial da consulta</param>
        /// <returns>Data do request fomatada ou data mínima do sistema</returns>
        public static DateTime DataInicial(string request)
        {
            DateTime data = string.IsNullOrEmpty(request) ? DateTime.Parse("01/01/1900 00:00:00") : DateTime.Parse(string.Format("{0:dd/MM/yyyy} 00:00:00", request));

            return data;
        }

        /// <summary>
        /// Retorna data inicial das pesquisas
        /// </summary>
        /// <param name="request">Request da data inicial da consulta</param>
        /// <returns>Data do request fomatada ou data mínima do sistema</returns>
        public static DateTime DataFinal(string request, DateTime dataInicial)
        {
            DateTime data = string.IsNullOrEmpty(request) ? DateTime.MaxValue : DateTime.Parse(request);
            if (dataInicial.Equals(data)) data = DateTime.Parse(string.Format("{0:dd/MM/yyyy} 23:59:59", dataInicial));

            return data;
        }

        /// <summary>
        /// Retorna o tipo do formato para valores decimais de acordo ao parâmetro 112
        /// </summary>
        /// <param name="request"></param>
        /// <param name="dataInicial"></param>
        /// <returns></returns>
        public static string CasaDecimal()
        {
            string CASAS_DECIMAIS = "";
            xcontEntities db = new xcontEntities();

            //if (true)
            //{
            //    CASAS_DECIMAIS = "{0}";
            //}
            //else
            //{
            //    CASAS_DECIMAIS = "{0:F0}";
            //}

            return CASAS_DECIMAIS;
        }

        /// <summary>
        /// Retorna o tipo do formato para valores decimais de acordo ao parâmetro 112
        /// </summary>
        /// <param name="request"></param>
        /// <param name="dataInicial"></param>
        /// <returns></returns>
        public static string Documentos()
        {
            xcontEntities db = new xcontEntities();

            string documentos = "";
            foreach (DOCUMENTOS d in db.DOCUMENTOS)
                documentos += string.Format("{0}:{1};", d.COD_DOC, d.DESC_DOC);

            return documentos.Substring(0, documentos.LastIndexOf(';'));
        }

        /// <summary>
        /// Retorna o tipo do formato para valores decimais de acordo ao parâmetro 112
        /// </summary>
        /// <param name="request"></param>
        /// <param name="dataInicial"></param>
        /// <returns></returns>
        public static string RegimesTributarios()
        {
            xcontEntities db = new xcontEntities();

            string regimes = "";

            foreach (REGIMES_TRIBUTARIOS d in db.REGIMES_TRIBUTARIOS)
            {
                regimes += string.Format("{0}:{1};", d.ID_RGTR, d.DESC_RGTR);
            }

            return regimes.Substring(0, regimes.LastIndexOf(';'));
        }

        /// <summary>
        /// Retorna o tipo do formato para valores decimais de acordo ao parâmetro 112
        /// </summary>
        /// <param name="request"></param>
        /// <param name="dataInicial"></param>
        /// <returns></returns>
        public static string UFs()
        {
            xcontEntities db = new xcontEntities();

            string ufs = "";
            foreach (UFS d in db.UFS)
                ufs += string.Format("{0}:{1};", d.SIGLA_UF, d.SIGLA_UF);

            return ufs.Remove(ufs.Length - 1, 1);
        }
    }

    public class PeriodosOptions
    {
        // Períodos

        /// <summary>
        /// Retorna uma lista com as opções de períodos
        /// </summary>
        /// <returns></returns>
        public static List<SelectListItem> PeriodosList()
        {
            return new List<SelectListItem>
            {
                new SelectListItem { Value = "A", Text = "Hoje" },
                new SelectListItem { Value = "B", Text = "Ontem" },
                new SelectListItem { Value = "C", Text = "Semana Atual" },
                new SelectListItem { Value = "D", Text = "Semana Passada" },
                new SelectListItem { Value = "F", Text = "Mês Anterior" },
                new SelectListItem { Value = "E", Text = "Mês Atual" },
                new SelectListItem { Value = "I", Text = "Mês Posterior" },
                new SelectListItem { Value = "G", Text = "Ano Atual" },
                new SelectListItem { Value = "H", Text = "Ano Passado" }
            };
        }

        /// <summary>
        /// Retorna a descrição de um período
        /// </summary>
        /// <param name="letter"></param>
        /// <returns></returns>
        public static string Periodo(char letter)
        {
            try
            {
                return PeriodosList().Find(p => p.Value.Equals(letter.ToString())).Text;
            }
            catch
            {
                return string.Empty;
            }
        }

        /// <summary>
        /// Retorna as datas de início e término em razão do período selecionado
        /// </summary>
        /// <param name="letter"></param>
        /// <returns></returns>
        public static DateTime[] Datas(char? letter)
        {
            DateTime[] datas;
            DateTime first;
            DateTime last;
            switch (letter.ToString())
            {
                case "A":
                    datas = new DateTime[] { DateTime.Now, DateTime.Now };
                    break;
                case "B":
                    datas = new DateTime[] { DateTime.Now.AddDays(-1), DateTime.Now.AddDays(-1) };
                    break;
                case "C":
                    first = DateTime.Now;
                    while (!first.DayOfWeek.Equals(DayOfWeek.Sunday))
                    {
                        first = first.AddDays(-1);
                    }
                    last = first.AddDays(6);
                    datas = new DateTime[] { first, last };
                    break;
                case "D":
                    first = DateTime.Now;
                    while (!first.DayOfWeek.Equals(DayOfWeek.Sunday))
                    {
                        first = first.AddDays(-1);
                    }
                    last = first.AddDays(6);
                    datas = new DateTime[] { first.AddDays(-7), last.AddDays(-7) };
                    break;
                case "E":
                    first = DateTime.Parse("01/" + DateTime.Now.ToString("MM/yyyy"));
                    last = first.AddMonths(1).AddDays(-1);
                    datas = new DateTime[] { first, last };
                    break;
                case "F":
                    first = DateTime.Parse("01/" + DateTime.Now.ToString("MM/yyyy")).AddMonths(-1);
                    last = first.AddMonths(1).AddDays(-1);
                    datas = new DateTime[] { first, last };
                    break;
                case "G":
                    first = DateTime.Parse("01/01/" + DateTime.Now.ToString("yyyy"));
                    last = first.AddYears(1).AddDays(-1);
                    datas = new DateTime[] { first, last };
                    break;
                case "H":
                    first = DateTime.Parse("01/01/" + DateTime.Now.ToString("yyyy"));
                    last = first.AddYears(1).AddDays(-1);
                    datas = new DateTime[] { first.AddYears(-1), last.AddYears(-1) };
                    break;
                case "I":
                    first = DateTime.Parse("01/" + DateTime.Now.ToString("MM/yyyy"));
                    last = first.AddMonths(1).AddDays(-1);
                    datas = new DateTime[] { first.AddMonths(1), last.AddMonths(1) };
                    break;
                default:
                    datas = new DateTime[] { };
                    break;
            }

            return datas;
        }

        public static DateTime FirstDayOfMonthFromDateTime(DateTime dateTime)
        {
            return new DateTime(dateTime.Year, dateTime.Month, 1);
        }

        public static DateTime LastDayOfMonthFromDateTime(DateTime dateTime)
        {
            DateTime firstDayOfTheMonth = new DateTime(dateTime.Year, dateTime.Month, 1);
            return firstDayOfTheMonth.AddMonths(1).AddDays(-1);
        }

        public static Int32 LastDayOfMonthFromInteger(DateTime dateTime)
        {
            DateTime firstDayOfTheMonth = new DateTime(dateTime.Year, dateTime.Month, 1);
            return firstDayOfTheMonth.AddMonths(1).AddDays(-1).Day;
        }
    }
}